package source.Control
{
    import net.flashpunk.Entity;
    import net.flashpunk.FP;
    import net.flashpunk.graphics.Graphiclist;
    import net.flashpunk.graphics.Image;
    import net.flashpunk.graphics.Text;
    import net.flashpunk.utils.Input;
    import net.flashpunk.utils.Key;
    import net.flashpunk.World;
    import source.Assets;
    import source.Global;
    import source.Control.Juego;
    import source.Objetos.PJ;
    
	public class Menu extends World
	{        
        //fade in/out:
		public var fade:Image = Image.createRect(FP.width, FP.height, 0); //rectángulo negro que se opacará para realizar el fade-out, y a la inversa
        public var fadeIn:Boolean = false;                                //indica que la funcion executeFade debe realizar un fade in
        public var fadeOut:Boolean = false;                               //indica que la funcion executeFade debe realizar un fade out
        public var fadeReady:Boolean = true;                              //false si se está realizando un fade en este momento
        
        //elementos visuales:
		public var marcoMenus:Image;              //fondo para enmarcar el texto de los menús
		public var contenedorTextoMenu:Entity;    //entidad que contendrá el texto de los menús
		public var selector:Entity;               //entidad que contendrá el selector de opciones
		public var display:Entity;                //variable that contains the entity that holds all the graphics
        public const opacidadMarco:Number = 0.75; //la opacidad del marco de los menús
        public const colorMarco:uint = 0x000020;  //el color del marco de los menús
        
        //Constantes de ajuste de posicionamiento:
        public const offset:uint = 40;                  //desplazamiento de centrado general
        public const incrOffsetG:Number = 38;           //desplazamiento del selector de opciones, cuando el menú tiene un tipo de letra grande
        public const incrOffsetG_inicial:Number = 2;    //desplazamiento inicial del selector de opciones, cuando el menú tiene un tipo de letra grande
        public const incrOffsetP:Number = 21.5;         //desplazamiento del selector de opciones, cuando el menú tiene un tipo de letra pequeño
        public const incrOffsetP_inicial:Number = 1.65; //desplazamiento inicial del selector de opciones, cuando el menú tiene un tipo de letra pequeño
		
        //varios:
        public var menuActual:uint;         //el menú actual donde nos encontramos
		public var seleccion:int = 0;       //selección actual del menu
        public var numOpciones:uint;        //número de opciones seleccionables en el menú
		public var cambios:Boolean = false; //true si ha habido un cambio de selección en un menú (para ahorrar trabajo cada frame)
        public var operation:uint = 0;      //la operación a realizar tras un fade-out (nueva partida, continuar, salir, reanudar partida...)
        
        //Constantes de los códigos de los menús:
        public static const
            MNU_ERROR:uint                        = 0,
            MNU_PRINCIPAL:uint                    = 1,
            MNU_NUEVA_PARTIDA:uint                = 2,
            MNU_CONFIRMAR_SOBREESCRIBIR_SLOT:uint = 3,
            MNU_CONTINUAR_PARTIDA:uint            = 4,
            MNU_OPCIONES:uint                     = 5,
            MNU_CREDITOS:uint                     = 6,
            MNU_CONFIRMAR_SALIR_JUEGO:uint        = 7,
            MNU_PAUSA:uint                        = 8,
            MNU_OPCIONES_EN_PAUSA:uint            = 9,
            MNU_CONFIRMAR_SALIR_PARTIDA:uint      = 10;
            
        //Constantes de los códigos de las operaciones tras un fade-out:
        public static const
            OP_ERROR:uint                = 0,
            OP_NEW_GAME_SLOT_1:uint      = 1,
            OP_NEW_GAME_SLOT_2:uint      = 2,
            OP_NEW_GAME_SLOT_3:uint      = 3,
            OP_CONTINUE_GAME_SLOT_1:uint = 4,
            OP_CONTINUE_GAME_SLOT_2:uint = 5,
            OP_CONTINUE_GAME_SLOT_3:uint = 6,
            OP_RESUME:uint               = 7;
        
        /**
         * Menu
         * Constructor
         */
		public function Menu() {
			//configuramos las teclas
			Input.define("Arr",    Key.UP);
			Input.define("Ab",     Key.DOWN);
			Input.define("Sel",    Key.A, Key.ENTER);
			Input.define("Volver", Key.ESCAPE);
		}
		
        /**
         * begin
         * Es llamado cuando el mundo pasa a ser el activo del engine (esto sucede al lanzar el juego o al entrar en el menú de pausa)
         */
		override public function begin():void {
            removeAll();
            
            if (!Global.enJuego) {
                setMenu(MNU_PRINCIPAL);
                fadeIn = true;        //ordenamos que se realice un fade in al cargar el menú
                fade.visible = true;  //hacemos visible el rectángulo del fade para permitir los fades in/out
            }
            else {
                setMenu(MNU_PAUSA);
                fade.visible = false; //hacemos invisible el rectángulo del fade para que no moleste (seguramente estará opaco debido al fade out anterior)
            }
            
            cambios = true; //indicamos que han habido cambios en la opción seleccionada del menú para que el selector se recoloque
        }
        
        /**
         * update
         * Es llamado cada frame
         */
		override public function update():void {
			//if the menu selection changed
            if (cambios) {
                //si la selección está "fuera de rango", la reseteamos según en qué menú nos encontremos:
                if (seleccion < 0)
                    seleccion = numOpciones - 1;
                else if (seleccion > (numOpciones - 1))
                    seleccion = 0;
                
                //Reubicamos el selector según la selección actual y el tipo de menú actual:
                if (menuActual == MNU_OPCIONES || menuActual == MNU_OPCIONES_EN_PAUSA)
                    selector.y = marcoMenus.y + (incrOffsetP_inicial + seleccion) * incrOffsetP;
                else
                    selector.y = marcoMenus.y + (incrOffsetG_inicial + seleccion) * incrOffsetG;
                    
                cambios = false; //bajamos el flag "ha habido cambios"
            }
            
            if (fadeReady) {
                //change selection
                if      (Input.pressed("Ab"))
                    seleccion++;
                else if (Input.pressed("Arr"))
                    seleccion--;
                else if (Input.pressed("Sel"))
                    navegarMenus();
                else if (Input.pressed("Volver")) {
                    if (!Global.enJuego && (menuActual != MNU_PRINCIPAL))
                        setMenu(MNU_PRINCIPAL); //si no estamos jugando, volvemos al menú principal
                    else if (Global.enJuego)
                        FP.world = Global.juego; //si estamos en plena partida, volvemos a ella
                }
                
                if (Input.pressed(Key.ANY)) cambios = true;
            }
                
            executeFade();
		}
        
        /**
         * navegarMenus
         * Navega entre menús
         */
        public function navegarMenus():void {            
            switch (menuActual) {
                case MNU_PRINCIPAL:
                    switch (seleccion) {
                        case 0: setMenu(MNU_NUEVA_PARTIDA); break;
                        case 1: setMenu(MNU_CONTINUAR_PARTIDA); break;
                        case 2: setMenu(MNU_OPCIONES); break;
                        case 3: setMenu(MNU_CREDITOS); break;
                        case 4: setMenu(MNU_CONFIRMAR_SALIR_JUEGO); break;
                    }
                    break;
                    
                case MNU_NUEVA_PARTIDA:
                    switch (seleccion) {
                        case 0:
                            Global.slot = 1;
                            if (Juego.slotEnUso(Global.slot)) {
                                setMenu(MNU_CONFIRMAR_SOBREESCRIBIR_SLOT);
                            }
                            else {
                                fadeOut = true;
                                operation = OP_NEW_GAME_SLOT_1;
                            }
                            break;
                        case 1:
                            Global.slot = 2;
                            if (Juego.slotEnUso(Global.slot)) {
                                setMenu(MNU_CONFIRMAR_SOBREESCRIBIR_SLOT);
                            }
                            else {
                                fadeOut = true;
                                operation = OP_NEW_GAME_SLOT_2;
                            }
                            break;
                        case 2:
                            Global.slot = 3;
                            if (Juego.slotEnUso(Global.slot)) {
                                setMenu(MNU_CONFIRMAR_SOBREESCRIBIR_SLOT);
                            }
                            else {
                                fadeOut = true;
                                operation = OP_NEW_GAME_SLOT_3;
                            }
                            break;
                        case 3:
                            setMenu(MNU_PRINCIPAL);
                            break;
                    }
                    break;
                    
                case MNU_CONFIRMAR_SOBREESCRIBIR_SLOT:
                    switch (seleccion) {
                        case 0: //No
                            setMenu(MNU_NUEVA_PARTIDA);
                            break;
                            
                        case 1: //Si
                            fadeOut = true;
                            switch (Global.slot) {
                                case 1: operation = OP_NEW_GAME_SLOT_1; break;
                                case 2: operation = OP_NEW_GAME_SLOT_2; break;
                                case 3: operation = OP_NEW_GAME_SLOT_3; break;
                            }
                            break;
                    }
                    break;
                    
                case MNU_CONTINUAR_PARTIDA:
                    switch (seleccion) {
                        case 0: //Slot 1
                            if (Juego.slotEnUso(1)) {
                                fadeOut = true;
                                operation = OP_CONTINUE_GAME_SLOT_1;
                            }
                            break;
                            
                        case 1: //Slot 2
                            if (Juego.slotEnUso(2)) {
                                fadeOut = true;
                                operation = OP_CONTINUE_GAME_SLOT_2;
                            }
                            break;
                            
                        case 2: //Slot 3
                            if (Juego.slotEnUso(3)) {
                                fadeOut = true;
                                operation = OP_CONTINUE_GAME_SLOT_3;
                            }
                            break;
                            
                        case 3: //Volver
                            setMenu(MNU_PRINCIPAL);
                        break;
                    }
                    break;
                    
                case MNU_OPCIONES:
                    switch (seleccion) {
                        case 14:
                            setMenu(MNU_PRINCIPAL);
                            break;
                    }
                    break;
                    
                case MNU_CREDITOS:
                    setMenu(MNU_PRINCIPAL);
                    break;
                    
                case MNU_CONFIRMAR_SALIR_JUEGO:
                    switch (seleccion) {
                        case 0: //No
                            setMenu(MNU_PRINCIPAL);
                            break;
                            
                        case 1: //Si
                            break;
                    }
                    break;
                    
                case MNU_PAUSA:
                    switch (seleccion) {
                        case 0: FP.world = Global.juego; break; //reanudar partida
                        case 1: setMenu(MNU_OPCIONES_EN_PAUSA); break;
                        case 2: setMenu(MNU_CONFIRMAR_SALIR_PARTIDA); break;
                    }
                    break;
                    
                case MNU_OPCIONES_EN_PAUSA:
                    switch (seleccion) {
                        case 14:
                            setMenu(MNU_PAUSA);
                            break;
                    }
                    break;
                    
                case MNU_CONFIRMAR_SALIR_PARTIDA:
                    switch (seleccion) {
                        case 0: //No
                            setMenu(MNU_PAUSA);
                            break;
                        case 1: //Si
                            Global.enJuego = false;
                            begin(); //llamamos a begin() para que todo se "recoloque" como si acabáramos de cargar este World
                            break;
                    }
                    break;
                
                default:
                    setMenu(MNU_PRINCIPAL);
            }
        }
        
        /**
         * setMenu
         * Imprime las diferentes opciones de los menús y configura sus parámetros de control
         */
        public function setMenu(_menu:uint):void {
            var textoMenu:Text;
            var textoSelector:Text;
            menuActual = _menu;
            removeAll();
            
            switch (menuActual) {
                case MNU_PRINCIPAL:
                    //configuramos otros datos de este menú:
                    numOpciones = 4;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(315, 285, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = marcoMenus.y = offset;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(new Image(Assets.MENU_FONDO),
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("PRINCIPAL\n"
                                       + "\n"
                                       + "Nueva partida\n"
                                       + "Continuar\n"
                                       + "Opciones\n"
                                       + "Créditos\n ");
                                       //+ "Créditos\n"
                                       //+ "Salir\n ");
                    textoMenu.size = 32;
                    
                    //si estamos en este menú es que no estamos jugando:
                    Global.enJuego = false;
                    break;
                    
                case MNU_NUEVA_PARTIDA:
                    //configuramos otros datos de este menú:
                    numOpciones = 4;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(375, 280, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = marcoMenus.y = offset;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(new Image(Assets.MENU_FONDO),
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("NUEVA PARTIDA\n\n");
                    if (Juego.slotEnUso(1)) textoMenu.text = textoMenu.text + "Slot 1\n";
                    else textoMenu.text = textoMenu.text + "<slot vacío>\n";
                    if (Juego.slotEnUso(2)) textoMenu.text = textoMenu.text + "Slot 2\n";
                    else textoMenu.text = textoMenu.text + "<slot vacío>\n";
                    if (Juego.slotEnUso(3)) textoMenu.text = textoMenu.text + "Slot 3\n";
                    else textoMenu.text = textoMenu.text + "<slot vacío>\n";
                    textoMenu.text = textoMenu.text + "(Volver)\n ";
                    textoMenu.size = 32;
                    
                    //si estamos en este menú es que no estamos jugando:
                    Global.enJuego = false;
                    break;
                    
                case MNU_CONFIRMAR_SOBREESCRIBIR_SLOT:
                    //configuramos otros datos de este menú:
                    numOpciones = 2;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(550, 200, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = marcoMenus.y = offset;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(new Image(Assets.MENU_FONDO),
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("Slot ocupado, ¿sobreescribir?\n"
                                       + "\n"
                                       + "No\n"
                                       + "Sí\n ");
                    textoMenu.size = 32;
                    
                    //si estamos en este menú es que no estamos jugando:
                    Global.enJuego = false;
                    break;
                    
                case MNU_CONTINUAR_PARTIDA:
                    //configuramos otros datos de este menú:
                    numOpciones = 4;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(375, 280, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = marcoMenus.y = offset;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(new Image(Assets.MENU_FONDO),
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("CONTINUAR\n\n");
                    if (Juego.slotEnUso(1)) textoMenu.text = textoMenu.text + "Slot 1\n";
                    else textoMenu.text = textoMenu.text + "<slot vacío>\n";
                    if (Juego.slotEnUso(2)) textoMenu.text = textoMenu.text + "Slot 2\n";
                    else textoMenu.text = textoMenu.text + "<slot vacío>\n";
                    if (Juego.slotEnUso(3)) textoMenu.text = textoMenu.text + "Slot 3\n";
                    else textoMenu.text = textoMenu.text + "<slot vacío>\n";
                    textoMenu.text = textoMenu.text + "(Volver)\n ";
                    textoMenu.size = 32;
                    
                    //si estamos en este menú es que no estamos jugando:
                    Global.enJuego = false;
                    break;
                    
                case MNU_OPCIONES:
                    //configuramos otros datos de este menú:
                    numOpciones = 15;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(300, 465, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = marcoMenus.y = offset;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(new Image(Assets.MENU_FONDO),
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("OPCIONES\n"
                                       + "\n"
                                       + "Volumen Efectos:\t100%\n"
                                       + "Volumen Música:\t80%\n"
                                       + "Despl. Dch.\t\tRIGHT\n"
                                       + "Despl. Izq.\t\tLEFT\n"
                                       + "Subir escaleras\tUP\n"
                                       + "Bajar escaleras\tDOWN\n"
                                       + "Acción\t\t\tA\n"
                                       + "Salto\t\t\tS\n"
                                       + "Disparo\t\t\tD\n"
                                       + "Golpe Descend.\tDOWN\n"
                                       + "Guardar\t\t\tDOWN\n"
                                       + "Mapa\t\t\tM\n"
                                       + "Suicidio\t\t\tK\n"
                                       + "Pausa\t\t\tESC\n"
                                       + "(Volver)\n ");
                    textoMenu.size = 18;
                    
                    //si estamos en este menú es que no estamos jugando:
                    Global.enJuego = false;
                    break;
                    
                case MNU_CREDITOS:
                    //configuramos otros datos de este menú:
                    numOpciones = 0;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(250, 475, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = FP.halfWidth - marcoMenus.width/2;
                    marcoMenus.y = FP.halfHeight - marcoMenus.height/2;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(new Image(Assets.MENU_FONDO),
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("EXPLOSIVE BRAINS\n"
                                       + "\n"
                                       + "Arte Conceptual:\n"
                                       + "\tTimur Gran\n"
                                       + "Pixelart:\n"
                                       + "\tSergio Gracia\n"
                                       + "Pixelart adicional:\n"
                                       + "\tBorja Gracia\n"
                                       + "\n"
                                       + "Diseño:\n"
                                       + "\tAndrés Orcajo\n"
                                       + "\tÁngel Rebolleda\n"
                                       + "\tBorja Gracia\n"
                                       + "\tGuillermo Orcajo\n"
                                       + "\tSergio Gracia\n"
                                       + "Diseño de Niveles:\n"
                                       + "\tÁngel Rebolleda\n"
                                       + "\n"
                                       + "Programación:\n"
                                       + "\tAndrés Orcajo\n"
                                       + "\tBorja Gracia\n"
                                       + "\tGuillermo Orcajo\n"
                                       + " ");
                    textoMenu.size = 16;
                    
                    //si estamos en este menú es que no estamos jugando:
                    Global.enJuego = false;
                    break;
                    
                case MNU_CONFIRMAR_SALIR_JUEGO:
                    //configuramos otros datos de este menú:
                    numOpciones = 2;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(200, 200, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = marcoMenus.y = offset;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(new Image(Assets.MENU_FONDO),
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("¿Salir?\n"
                                       + "\n"
                                       + "No\n"
                                       + "Sí\n ");
                    textoMenu.size = 32;
                    
                    //si estamos en este menú es que no estamos jugando:
                    Global.enJuego = false;
                    break;
                    
                case MNU_PAUSA:                    
                    //configuramos otros datos de este menú:
                    numOpciones = 3;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(325, 250, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = FP.halfWidth - marcoMenus.width/2;
                    marcoMenus.y = FP.halfHeight - marcoMenus.height/2;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(Global.bufferPantalla,
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("PAUSA\n"
                                       + "\n"
                                       + "(Reanudar)\n"
                                       + "Opciones\n"
                                       + "Menú principal\n ");
                    textoMenu.size = 32;
                    
                    //si estamos en este menú es que sí estamos jugando:
                    Global.enJuego = true;
                    break;
                    
                case MNU_OPCIONES_EN_PAUSA:
                    //configuramos otros datos de este menú:
                    numOpciones = 15;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(300, 465, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = FP.halfWidth - marcoMenus.width/2;
                    marcoMenus.y = FP.halfHeight - marcoMenus.height/2;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(Global.bufferPantalla,
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("OPCIONES\n"
                                       + "\n"
                                       + "Volumen Efectos:\t100%\n"
                                       + "Volumen Música:\t80%\n"
                                       + "Despl. Dch.\t\tRIGHT\n"
                                       + "Despl. Izq.\t\tLEFT\n"
                                       + "Subir escaleras\tUP\n"
                                       + "Bajar escaleras\tDOWN\n"
                                       + "Acción\t\t\tA\n"
                                       + "Salto\t\t\tS\n"
                                       + "Disparo\t\t\tD\n"
                                       + "Golpe Descend.\tDOWN\n"
                                       + "Guardar\t\t\tDOWN\n"
                                       + "Mapa\t\t\tM\n"
                                       + "Suicidio\t\t\tK\n"
                                       + "Pausa\t\t\tESC\n"
                                       + "(Volver)\n ");
                    textoMenu.size = 18;
                    
                    //si estamos en este menú es que sí estamos jugando:
                    Global.enJuego = true;
                    break;
                    
                case MNU_CONFIRMAR_SALIR_PARTIDA:
                    //configuramos otros datos de este menú:
                    numOpciones = 2;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(625, 200, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = FP.halfWidth - marcoMenus.width/2;
                    marcoMenus.y = FP.halfHeight - marcoMenus.height/2;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(Global.bufferPantalla,
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("Tus progresos se perderán, ¿salir?\n"
                                       + "\n"
                                       + "No\n"
                                       + "Sí\n ");
                    textoMenu.size = 32;
                    
                    //si estamos en este menú es que sí estamos jugando:
                    Global.enJuego = true;
                    break;
                    
                default:
                    //indicamos que nos encontramos en el menú de error:
                    menuActual = MNU_ERROR;
                    
                    //configuramos otros datos de este menú:
                    numOpciones = 0;
                    
                    //configuramos el marco de los menús:
                    marcoMenus = Image.createRect(200, 85, colorMarco, opacidadMarco); //fondo para enmarcar el texto de los menús
                    marcoMenus.x = FP.halfWidth - marcoMenus.width/2;
                    marcoMenus.y = FP.halfHeight - marcoMenus.height/2;
                    
                    //añadimos las imágenes fijas al mundo:
                    add(display = new Entity(0, 0, new Graphiclist(new Image(Assets.MENU_FONDO),
                                                                   marcoMenus,
                                                                   fade)));
                    
                    //configuramos el texto del menú principal:
                    textoMenu = new Text("ERROR\n ");
                    textoMenu.size = 32;
                    
                    //si estamos en este menú es que tenemos algún error, por lo que dejamos de jugar:
                    Global.enJuego = false;
            }
            
            //configuramos el selector de opciones:
            textoSelector = new Text("·");
            textoSelector.size = 72;
            textoSelector.font = "ModernAntiqua";
            selector = new Entity(marcoMenus.x + 10, -50, textoSelector); //lo colocamos inicialmente "fuera de vista" porque update() lo reubicúa...
            if (numOpciones) add(selector); //sólo agregamos el selector al mundo si no estamos en el menú créditos
            
            //terminamos de configurar el texto del menú principal:
            textoMenu.font = "ModernAntiqua";
            contenedorTextoMenu = new Entity(marcoMenus.x + offset, marcoMenus.y + offset/2, textoMenu);
            add(contenedorTextoMenu);
            
            //reseteamos la posición del selector:
            seleccion = 0;
        }
        
        /**
         * executeFade
         * Es llamado en el update de cada frame, para gestionar los fade in/out y lo que sucede tras ellos
         */
        public function executeFade():void {
            const velocidadFade:Number = 0.08;
            
            //Fade In:
            if (fadeIn && !fadeOut) {
                if ((fade.alpha <= 1) && (fade.alpha > 0)) {
                    fade.alpha -= velocidadFade;
                    fadeReady = false;
                }
                else {
                    contenedorTextoMenu.visible = true;
                    selector.visible = true;
                    fadeIn = false;
                    fadeReady = true;
                }
            }
            
            //Fade Out:
            else if (fadeOut && !fadeIn) {
                if ((fade.alpha >= 0) && (fade.alpha < 1)) {
                    fade.alpha += velocidadFade;
                    contenedorTextoMenu.visible = false;
                    selector.visible = false;
                    fadeReady = false;
                }
                else {
                    fadeOut = false;
                    fadeReady = true;
                    executeOperation();
                }
            }
        }
        
        /**
         * executeOperation
         * Es llamado tras terminar un fade out, para realizar alguna operación (nueva partida, continuar, etc...)
         */
        public function executeOperation():void {
            //Primer switch para seleccionar un slot, en el caso de que haya que hacerlo:
            //(ojo con los cases sin break, esa pirula funciona omo una OR lógica)
            switch(operation) {
                case OP_NEW_GAME_SLOT_1:
                case OP_CONTINUE_GAME_SLOT_1:
                    Global.slot = 1;
                    break;
                case OP_NEW_GAME_SLOT_2:
                case OP_CONTINUE_GAME_SLOT_2:
                    Global.slot = 2;
                    break;
                case OP_NEW_GAME_SLOT_3:
                case OP_CONTINUE_GAME_SLOT_3:
                    Global.slot = 3;
                    break;
            }
            
            //Segundo switch, para realizar todo lo demás, ya sabiendo el slot a utilizar, si es que se va a utilizar alguno:
            //(ojo con los cases sin break, esa pirula funciona omo una OR lógica)
            switch(operation) {
                case OP_NEW_GAME_SLOT_1:
                case OP_NEW_GAME_SLOT_2:
                case OP_NEW_GAME_SLOT_3:
                    Global.juego = new Juego();
                    Global.pj.resetear();
                    FP.world = Global.juego;
                    break;
                case OP_CONTINUE_GAME_SLOT_1:
                case OP_CONTINUE_GAME_SLOT_2:
                case OP_CONTINUE_GAME_SLOT_3:
                    Juego.cargarPartida(); //cargamos los datos contenidos en el fichero del slot que toque
                    Global.juego = new Juego(Global.savepointDestino); //Global.savepointDestino ya ha sido modificada
                    FP.world = Global.juego;                           //por Juego.cargarPartida(), corresponde a la
                    break;                                             //ID de la pantalla a cargar
                case OP_RESUME:
                    FP.world = Global.juego;
                    break;
            }
        }
	}
}















//